package 炫彩元素类

import (
	objectbase "gitee.com/go_888/xcgui/xcgui/objectbase"
	xc "gitee.com/go_888/xcgui/xcgui/xc"
	xcc "gitee.com/go_888/xcgui/xcgui/xcc"
)

// X结构_基础元素 基础元素.
type X结构_基础元素 struct {
	objectbase.X结构_窗口组件
}

// 元素_创建, 创建基础元素.
//
// y: 元素y坐标.
//
// cx: 宽度.
//
// cy: 高度.
//
// hParent: 父为窗口句柄或元素句柄.
func X创建基础元素(x坐标, y坐标, 宽度, 高度 int32, 父窗口句柄 int) *X结构_基础元素 {
	p := &X结构_基础元素{}
	p.X设置句柄(xc.X元素_创建(x坐标, y坐标, 宽度, 高度, 父窗口句柄))
	return p
}

// 从句柄创建对象.
func X创建基础元素并按句柄(句柄 int) *X结构_基础元素 {
	p := &X结构_基础元素{}
	p.X设置句柄(句柄)
	return p
}

// 从name创建对象, 失败返回nil.
func X创建基础元素并按名称(名称 string) *X结构_基础元素 {
	handle := xc.X取对象并按名称(名称)
	if handle > 0 {
		p := &X结构_基础元素{}
		p.X设置句柄(handle)
		return p
	}
	return nil
}

// 从UID创建对象, 失败返回nil.
func X创建基础元素并按UID(UID int32) *X结构_基础元素 {
	handle := xc.X取对象并按UID(UID)
	if handle > 0 {
		p := &X结构_基础元素{}
		p.X设置句柄(handle)
		return p
	}
	return nil
}

// 从UID名称创建对象, 失败返回nil.
func X创建基础元素并按UID名称(名称 string) *X结构_基础元素 {
	handle := xc.X取对象并按UID名称(名称)
	if handle > 0 {
		p := &X结构_基础元素{}
		p.X设置句柄(handle)
		return p
	}
	return nil
}

// 元素_注册事件C, 注册事件C方式, 省略2参数.
//
// nEvent: 事件类型: xcc.XE_.
//
// fun: 事件函数.
func (e *X结构_基础元素) X注册事件C(事件类型 xcc.X元素事件, fun interface{}) bool {
	return xc.X元素_注册事件C(e.X句柄, 事件类型, fun)
}

// 元素_注册事件C1, 注册事件C1方式, 省略1参数.
//
// nEvent: 事件类型: xcc.XE_.
//
// fun: 事件函数.
func (e *X结构_基础元素) X注册事件C1(事件类型 xcc.X元素事件, fun interface{}) bool {
	return xc.X元素_注册事件C1(e.X句柄, 事件类型, fun)
}

// 元素_移除事件C.
//
// nEvent: 事件类型: xcc.XE_.
//
// fun: 事件函数.
func (e *X结构_基础元素) X移除事件C(事件类型 xcc.X元素事件, fun interface{}) bool {
	return xc.X元素_移除事件C(e.X句柄, 事件类型, fun)
}

// 元素_移除事件. 只适用于 AddEvent_ 方式添加的事件.
//
// nEvent: 事件类型: xcc.XE_.
//
// index: 使用 AddEvent_ 函数返回的回调函数索引.
//   - 为空时, 直接移除事件.
//   - 不为空时, 移除指定索引的回调函数.
func (e *X结构_基础元素) RemoveEvent(nEvent xcc.X元素事件, index ...int) *X结构_基础元素 {
	if len(index) > 0 {
		EventHandler.RemoveCallBack(e.X句柄, nEvent, index[0])
	} else {
		cbPtr := EventHandler.EventInfoMap[e.X句柄][nEvent].EvnetFuncPtr
		if cbPtr > 0 {
			xc.X元素_注册事件CEx(e.X句柄, nEvent, cbPtr)
		}
		EventHandler.RemoveEvent(e.X句柄, nEvent)
	}
	return e
}

// 元素_注册事件CEx, 注册事件C方式, 省略2参数, 和非Ex版相比只是最后一个参数不同.
//
// nEvent: 事件类型: xcc.XE_.
//
// pFun: 事件函数指针, 使用 syscall.NewCallback() 生成.
func (e *X结构_基础元素) X注册事件CEx(事件类型 xcc.X元素事件, 回调函数 uintptr) bool {
	return xc.X元素_注册事件CEx(e.X句柄, 事件类型, 回调函数)
}

// 元素_注册事件C1Ex, 注册事件C1方式, 省略1参数, 和非Ex版相比只是最后一个参数不同.
//
// nEvent: 事件类型: xcc.XE_.
//
// pFun: 事件函数指针, 使用 syscall.NewCallback() 生成.
func (e *X结构_基础元素) X注册事件C1Ex(事件类型 xcc.X元素事件, 回调函数 uintptr) bool {
	return xc.X元素_注册事件C1Ex(e.X句柄, 事件类型, 回调函数)
}

// 元素_移除事件CEx, 和非Ex版相比只是最后一个参数不同.
//
// nEvent: 事件类型: xcc.XE_.
//
// pFun: 事件函数指针, 使用 syscall.NewCallback() 生成.
func (e *X结构_基础元素) X移除事件CEx(事件类型 xcc.X元素事件, 回调函数 uintptr) bool {
	return xc.X元素_移除事件CEx(e.X句柄, 事件类型, 回调函数)
}

// 元素_发送事件.
//
// nEvent: 事件类型: xcc.XE_.
//
// wParam: 参数.
//
// lParam: 参数.
func (e *X结构_基础元素) X发送事件(事件类型 xcc.X元素事件, 参数1, 参数2 uintptr) int32 {
	return xc.X元素_发送事件(e.X句柄, 事件类型, 参数1, 参数2)
}

// 元素_投递事件.
//
// nEvent: 事件类型: xcc.XE_.
//
// wParam: 参数.
//
// lParam: 参数.
func (e *X结构_基础元素) X投递事件(事件类型 xcc.X元素事件, 参数1, 参数2 uintptr) bool {
	return xc.X元素_投递事件(e.X句柄, 事件类型, 参数1, 参数2)
}

// 元素_取坐标.
//
// pRect: 坐标.
func (e *X结构_基础元素) X取坐标(矩形 *xc.X结构_矩形) *X结构_基础元素 {
	xc.X元素_取坐标(e.X句柄, 矩形)
	return e
}

// 元素_取坐标ex.
func (e *X结构_基础元素) X取坐标EX() xc.X结构_矩形 {
	rc := xc.X结构_矩形{}
	xc.X元素_取坐标(e.X句柄, &rc)
	return rc
}

// 元素_取逻辑坐标, 获取元素坐标, 逻辑坐标, 包含滚动视图偏移.
//
// pRect: 坐标.
func (e *X结构_基础元素) X取逻辑坐标(矩形 *xc.X结构_矩形) *X结构_基础元素 {
	xc.X元素_取逻辑坐标(e.X句柄, 矩形)
	return e
}

// 元素_取逻辑坐标ex, 获取元素坐标, 逻辑坐标, 包含滚动视图偏移.
func (e *X结构_基础元素) X取逻辑坐标EX() xc.X结构_矩形 {
	rc := xc.X结构_矩形{}
	xc.X元素_取逻辑坐标(e.X句柄, &rc)
	return rc
}

// 元素_取客户区坐标.
//
// pRect: 坐标.
func (e *X结构_基础元素) X取客户区坐标(矩形 *xc.X结构_矩形) *X结构_基础元素 {
	xc.X元素_取客户区坐标(e.X句柄, 矩形)
	return e
}

// 元素_取客户区坐标ex.
func (e *X结构_基础元素) X取客户区坐标EX() xc.X结构_矩形 {
	rc := xc.X结构_矩形{}
	xc.X元素_取客户区坐标(e.X句柄, &rc)
	return rc
}

// 元素_置宽度.
//
// nWidth: 宽度.
func (e *X结构_基础元素) X设置宽度(宽度 int32) *X结构_基础元素 {
	xc.X元素_设置宽度(e.X句柄, 宽度)
	return e
}

// 元素_置高度.
//
// nHeight: 高度.
func (e *X结构_基础元素) X设置高度(高度 int32) *X结构_基础元素 {
	xc.X元素_设置高度(e.X句柄, 高度)
	return e
}

// 元素_取宽度.
func (e *X结构_基础元素) X取宽度() int32 {
	return xc.X元素_取宽度(e.X句柄)
}

// 元素_取高度.
func (e *X结构_基础元素) X取高度() int32 {
	return xc.X元素_取高度(e.X句柄)
}

// 元素_窗口客户区坐标到元素客户区坐标, 窗口客户区坐标转换到元素客户区坐标.
//
// pRect: 坐标.
func (e *X结构_基础元素) X窗口客户区坐标到元素客户区坐标(矩形 *xc.X结构_矩形) *X结构_基础元素 {
	xc.X元素_窗口客户区坐标到元素客户区坐标(e.X句柄, 矩形)
	return e
}

// 元素_窗口客户区点到元素客户区, 窗口客户区坐标转换到元素客户区坐标.
//
// pPt: 坐标.
func (e *X结构_基础元素) X窗口客户区点到元素客户区(坐标 *xc.X结构_坐标) *X结构_基础元素 {
	xc.X元素_窗口客户区点到元素客户区(e.X句柄, 坐标)
	return e
}

// 元素_客户区坐标到窗口客户区, 元素客户区坐标转换到窗口客户区坐标.
//
// pRect: 坐标.
func (e *X结构_基础元素) X客户区坐标到窗口客户区(矩形 *xc.X结构_矩形) *X结构_基础元素 {
	xc.X元素_客户区坐标到窗口客户区(e.X句柄, 矩形)
	return e
}

// 元素_客户区点到窗口客户区, 元素客户区坐标转换到窗口客户区坐标.
//
// pPt: 坐标.
func (e *X结构_基础元素) X客户区点到窗口客户区(坐标 *xc.X结构_坐标) *X结构_基础元素 {
	xc.X元素_客户区点到窗口客户区(e.X句柄, 坐标)
	return e
}

// 元素_基于窗口客户区坐标.
//
// pRect: 坐标.
func (e *X结构_基础元素) X取窗口客户区坐标(矩形 *xc.X结构_矩形) *X结构_基础元素 {
	xc.X元素_基于窗口客户区坐标(e.X句柄, 矩形)
	return e
}

// 元素_基于窗口客户区坐标ex.
func (e *X结构_基础元素) X取窗口客户区坐标EX() xc.X结构_矩形 {
	rc := xc.X结构_矩形{}
	xc.X元素_基于窗口客户区坐标(e.X句柄, &rc)
	return rc
}

// 元素_取光标, 获取元素鼠标光标, 返回光标句柄.
func (e *X结构_基础元素) X取光标() uintptr {
	return xc.X元素_取光标(e.X句柄)
}

// 元素_置光标, 设置元素鼠标光标.
//
// hCursor: 光标句柄, 使用系统预定义的, 或者从文件加载.
//   - hCur := wapi.LoadImageW(0, wapi.IDC_HAND, wapi.IMAGE_CURSOR, 0, 0, wapi.LR_DEFAULTSIZE|wapi.LR_SHARED)
//   - hCur := wapi.LoadImageW(0, common.StrPtr("arrow.cur"), wapi.IMAGE_CURSOR, 0, 0, wapi.LR_LOADFROMFILE)
func (e *X结构_基础元素) X设置光标(光标句柄 uintptr) *X结构_基础元素 {
	xc.X元素_设置光标(e.X句柄, 光标句柄)
	return e
}

// 元素_添加子对象.
//
// hChild: 要添加的子元素句柄或形状对象句柄.
func (e *X结构_基础元素) X添加子对象(子元素 int) bool {
	return xc.X元素_添加子对象(e.X句柄, 子元素)
}

// 元素_插入子对象, 插入子对象到指定位置.
//
// hChild: 要插入的元素句柄或形状对象句柄.
//
// index: 插入位置索引.
func (e *X结构_基础元素) X插入子对象(子元素 int, 插入位置索引 int32) bool {
	return xc.X元素_插入子对象(e.X句柄, 子元素, 插入位置索引)
}

// 元素_置坐标, 如果返回0坐标没有改变, 如果大小改变返回2(触发XE_SIZE), 否则返回1(仅改变left,top,没有改变大小).
//
// pRect: 坐标.
//
// bRedraw: 是否重绘.
//
// nFlags: 调整布局标识位: xcc.AdjustLayout_.
//
// nAdjustNo: 调整布局流水号, 可填0.
func (e *X结构_基础元素) X设置坐标(矩形 *xc.X结构_矩形, 是否重绘 bool, 布局标识位 xcc.X调整布局标识位, 布局流水号 uint32) int32 {
	return xc.X元素_设置坐标(e.X句柄, 矩形, 是否重绘, 布局标识位, 布局流水号)
}

// 元素_置坐标扩展, 如果坐标未改变返回0, 如果大小改变返回2(触发XE_SIZE), 否则返回1.
//
// x: X坐标.
//
// y: Y坐标.
//
// cx: 宽度.
//
// cy: 高度.
//
// bRedraw: 是否重绘.
//
// nFlags: 调整布局标识位: xcc.AdjustLayout_.
//
// nAdjustNo: 调整布局流水号, 可填0.
func (e *X结构_基础元素) X设置坐标EX(坐标, Y坐标, 宽度, 高度 int32, 是否重绘 bool, 布局标识位 xcc.X调整布局标识位, 布局流水号 uint32) int32 {
	return xc.X元素_设置坐标EX(e.X句柄, 坐标, Y坐标, 宽度, 高度, 是否重绘, 布局标识位, 布局流水号)
}

// 元素_置逻辑坐标, 如果坐标未改变返回0, 如果大小改变返回2(触发XE_SIZE), 否则返回1.
//
// pRect: 坐标.
//
// bRedraw: 是否重绘.
//
// nFlags: 调整布局标识位: xcc.AdjustLayout_. 此参数将会传入XE_SIZE ,XE_ADJUSTLAYOUT 事件回调.
//
// nAdjustNo: 调整布局流水号, 可填0.
func (e *X结构_基础元素) X设置逻辑坐标(矩形 *xc.X结构_矩形, 是否重绘 bool, 布局标识位 xcc.X调整布局标识位, 布局流水号 uint32) int32 {
	return xc.X元素_设置逻辑坐标(e.X句柄, 矩形, 是否重绘, 布局标识位, 布局流水号)
}

// 元素_移动, 如果坐标未改变返回0, 如果大小改变返回2(触发XE_SIZE), 否则返回1.
//
// x: X坐标.
//
// y: Y坐标.
//
// bRedraw: 是否重绘.
//
// nFlags: 调整布局标识位: xcc.AdjustLayout_.
//
// nAdjustNo: 调整布局流水号, 可填0.
func (e *X结构_基础元素) X移动(坐标, Y坐标 int32, 是否重绘 bool, 布局标识位 xcc.X调整布局标识位, 布局流水号 uint32) int32 {
	return xc.X元素_移动(e.X句柄, 坐标, Y坐标, 是否重绘, 布局标识位, 布局流水号)
}

// 元素_移动逻辑坐标, 移动元素坐标, 逻辑坐标, 包含滚动视图偏移. 如果坐标未改变返回0, 如果大小改变返回2(触发XE_SIZE), 否则返回1.
//
// x: X坐标.
//
// y: Y坐标.
//
// bRedraw: 是否重绘.
//
// nFlags: 调整布局标识位: xcc.AdjustLayout_.
//
// nAdjustNo: 调整布局流水号, 可填0.
func (e *X结构_基础元素) X移动逻辑坐标(坐标, Y坐标 int32, 是否重绘 bool, 布局标识位 xcc.X调整布局标识位, 布局流水号 uint32) int32 {
	return xc.X元素_移动逻辑坐标(e.X句柄, 坐标, Y坐标, 是否重绘, 布局标识位, 布局流水号)
}

// 元素_判断绘制焦点.
func (e *X结构_基础元素) X是否绘制焦点() bool {
	return xc.X元素_是否绘制焦点(e.X句柄)
}

// 元素_判断启用, 元素是否为启用状态.
func (e *X结构_基础元素) X是否启用() bool {
	return xc.X元素_是否启用(e.X句柄)
}

// 元素_判断启用焦点, 元素是否启用焦点.
func (e *X结构_基础元素) X是否启用焦点() bool {
	return xc.X元素_是否启用焦点(e.X句柄)
}

// 元素_判断鼠标穿透, 元素是否启用鼠标穿透.
func (e *X结构_基础元素) X判断鼠标穿透() bool {
	return xc.X元素_是否鼠标穿透(e.X句柄)
}

// 元素_测试点击元素, 检测坐标点所在元素, 包含子元素的子元素. 成功时返回元素句柄.
//
// pPt: 坐标点.
func (e *X结构_基础元素) X测试点击元素(坐标点 *xc.X结构_坐标) int {
	return xc.X元素_测试点击元素(e.X句柄, 坐标点)
}

// 元素_判断背景透明.
func (e *X结构_基础元素) X是否背景透明() bool {
	return xc.X元素_是否背景透明(e.X句柄)
}

// 元素_判断启用事件_XE_PAINT_END, 是否启XE_PAINT_END用事件.
func (e *X结构_基础元素) X是否启用绘制完成事件() bool {
	return xc.X元素_是否启用绘制完成事件(e.X句柄)
}

// 元素_判断接受TAB, 是否接受Tab键输入; 例如: XRichEdit, XEdit.
func (e *X结构_基础元素) X是否接受TAB() bool {
	return xc.X元素_是否接受TAB(e.X句柄)
}

// 元素_判断接受切换焦点, 是否接受通过键盘切换焦点(方向键,TAB键).
func (e *X结构_基础元素) X是否接受切换焦点() bool {
	return xc.X元素_是否接受切换焦点(e.X句柄)
}

// 元素_判断启用_XE_MOUSEWHEEL, 判断是否启用鼠标滚动事件, 如果禁用那么事件会发送给他的父元素.
func (e *X结构_基础元素) X是否启用鼠标滚动事件() bool {
	return xc.X元素_是否启用鼠标滚动事件(e.X句柄)
}

// 元素_判断为子元素, 判断hChildEle是否为hEle的子元素.
//
// hChildEle: 子元素句柄.
func (e *X结构_基础元素) X是否为子元素(子元素句柄 int) bool {
	return xc.X元素_是否为子元素(e.X句柄, 子元素句柄)
}

// 元素_判断启用画布, 判断是否启用画布.
func (e *X结构_基础元素) X是否启用画布() bool {
	return xc.X元素_是否启用画布(e.X句柄)
}

// 元素_判断焦点, 判断是否拥有焦点.
func (e *X结构_基础元素) X是否焦点() bool {
	return xc.X元素_是否焦点(e.X句柄)
}

// 元素_判断焦点扩展, 判断该元素或该元素的子元素是否拥有焦点.
func (e *X结构_基础元素) X是否焦点EX() bool {
	return xc.X元素_是否焦点EX(e.X句柄)
}

// 元素_启用, 启用或禁用元素.
//
// bEnable: 启用或禁用.
func (e *X结构_基础元素) X启用(启用或禁用 bool) *X结构_基础元素 {
	xc.X元素_启用(e.X句柄, 启用或禁用)
	return e
}

// 元素_启用焦点, 启用焦点.
//
// bEnable: 是否启用.
func (e *X结构_基础元素) X启用焦点(是否启用 bool) *X结构_基础元素 {
	xc.X元素_启用焦点(e.X句柄, 是否启用)
	return e
}

// 元素_启用绘制焦点.
//
// bEnable: 是否启用.
func (e *X结构_基础元素) X启用绘制焦点(是否启用 bool) *X结构_基础元素 {
	xc.X元素_启用绘制焦点(e.X句柄, 是否启用)
	return e
}

// 元素_启用绘制边框, 启用或禁用绘制默认边框.
//
// bEnable: 是否启用.
func (e *X结构_基础元素) X启用绘制边框(是否启用 bool) *X结构_基础元素 {
	xc.X元素_启用绘制边框(e.X句柄, 是否启用)
	return e
}

// 元素_启用画布, 启用或禁用背景画布; 如果禁用那么将绘制在父的画布之上, 也就是说他没有自己的画布.
//
// bEnable: 是否启用.
func (e *X结构_基础元素) X启用画布(是否启用 bool) *X结构_基础元素 {
	xc.X元素_启用画布(e.X句柄, 是否启用)
	return e
}

// 元素_启用事件_XE_PAINT_END.
//
// bEnable: 是否启用.
func (e *X结构_基础元素) X启用绘制完成事件(是否启用 bool) *X结构_基础元素 {
	xc.X元素_启用绘制完成事件(e.X句柄, 是否启用)
	return e
}

// 元素_启用背景透明.
//
// bEnable: 是否启用.
func (e *X结构_基础元素) X启用背景透明(是否启用 bool) *X结构_基础元素 {
	xc.X元素_启用背景透明(e.X句柄, 是否启用)
	return e
}

// 元素_启用鼠标穿透. 启用鼠标穿透, 如果启用, 那么该元素不能接收到鼠标事件, 但是他的子元素不受影响, 任然可以接收鼠标事件.
//
// bEnable: 是否启用.
func (e *X结构_基础元素) X启用鼠标穿透(是否启用 bool) *X结构_基础元素 {
	xc.X元素_启用鼠标穿透(e.X句柄, 是否启用)
	return e
}

// 元素_启用接收TAB, 启用接收Tab输入.
//
// bEnable: 是否启用.
func (e *X结构_基础元素) X启用接收TAB(是否启用 bool) *X结构_基础元素 {
	xc.X元素_启用接收TAB(e.X句柄, 是否启用)
	return e
}

// 元素_启用切换焦点, 启用接受通过键盘切换焦点.
//
// bEnable: 是否启用.
func (e *X结构_基础元素) X启用切换焦点(是否启用 bool) *X结构_基础元素 {
	xc.X元素_启用切换焦点(e.X句柄, 是否启用)
	return e
}

// 元素_启用事件_XE_MOUSEWHEEL, 启用接收鼠标滚动事件, 如果禁用那么事件会传递给父元素.
//
// bEnable: 是否启用.
func (e *X结构_基础元素) X启用接收鼠标滚动事件(是否启用 bool) *X结构_基础元素 {
	xc.X元素_启用接收鼠标滚动事件(e.X句柄, 是否启用)
	return e
}

// 元素_移除, 移除元素, 但不销毁.
func (e *X结构_基础元素) X移除() *X结构_基础元素 {
	xc.X元素_移除(e.X句柄)
	return e
}

// 元素_置Z序, 设置元素Z序.
//
// index: 位置索引.
func (e *X结构_基础元素) X设置Z序(位置索引 int32) bool {
	return xc.X元素_设置Z序(e.X句柄, 位置索引)
}

// 元素_置Z序扩展, 设置元素Z序.
//
// hDestEle: 目标元素.
//
// nType: 类型, Zorder_.
func (e *X结构_基础元素) X设置Z序EX(目标元素 int, 类型 xcc.Z序位置) bool {
	return xc.X元素_设置Z序EX(e.X句柄, 目标元素, 类型)
}

// 元素_取Z序, 获取元素Z序索引, 位置索引.
func (e *X结构_基础元素) X取Z序() int32 {
	return xc.X元素_取Z序(e.X句柄)
}

// 元素_启用置顶, 设置元素置顶.
//
// bTopmost: 是否置顶显示.
func (e *X结构_基础元素) X启用置顶(是否置顶显示 bool) bool {
	return xc.X元素_启用置顶(e.X句柄, 是否置顶显示)
}

// 元素_重绘.
//
// bImmediate: 是否立即重绘, 通常为false即可.
func (e *X结构_基础元素) X重绘(是否重绘 ...bool) *X结构_基础元素 {
	b := false
	if len(是否重绘) > 0 {
		b = 是否重绘[0]
	}
	xc.X元素_重绘(e.X句柄, b)
	return e
}

// 元素_重绘指定区域.
//
// pRect: 相对于元素客户区坐标.
//
// bImmediate: 是否立即重绘.
func (e *X结构_基础元素) X重绘指定区域(客户区矩形 *xc.X结构_矩形, 是否重绘 bool) *X结构_基础元素 {
	xc.X元素_重绘指定区域(e.X句柄, 客户区矩形, 是否重绘)
	return e
}

// 元素_取子对象数量, 获取子对象(UI元素和形状对象)数量, 只检测当前层子对象.
func (e *X结构_基础元素) X取子对象数量() int32 {
	return xc.X元素_取子对象数量(e.X句柄)
}

// 元素_取子对象从索引, 获取子对象通过索引, 只检测当前层子对象.
//
// index: 索引.
func (e *X结构_基础元素) X取子对象并按索引(索引 int32) int {
	return xc.X元素_取子对象从索引(e.X句柄, 索引)
}

// 元素_取子对象从ID, 获取子对象通过ID, 只检测当前层子对象.
//
// nID: 元素ID.
func (e *X结构_基础元素) X取子对象并按ID(元素ID int32) int {
	return xc.X元素_取子对象从ID(e.X句柄, 元素ID)
}

// 元素_置边框大小.
//
// left: 左边大小.
//
// top: 上边大小.
//
// right: 右边大小.
//
// bottom: 下边大小.
func (e *X结构_基础元素) X设置边框大小(左边, 上边, 右边, 下边 int32) *X结构_基础元素 {
	xc.X元素_设置边框大小(e.X句柄, 左边, 上边, 右边, 下边)
	return e
}

// 元素_取边框大小.
//
// pBorder: 大小.
func (e *X结构_基础元素) X取边框大小(大小 *xc.X结构_矩形) *X结构_基础元素 {
	xc.X元素_取边框大小(e.X句柄, 大小)
	return e
}

// 元素_取边框大小ex.
func (e *X结构_基础元素) X取边框大小EX() xc.X结构_矩形 {
	rc := xc.X结构_矩形{}
	xc.X元素_取边框大小(e.X句柄, &rc)
	return rc
}

// 元素_置内填充大小.
//
// left: 左边大小.
//
// top: 上边大小.
//
// right: 右边大小.
//
// bottom: 下边大小.
func (e *X结构_基础元素) X设置内填充大小(左边, 上边, 右边, 下边 int32) *X结构_基础元素 {
	xc.X元素_设置内填充大小(e.X句柄, 左边, 上边, 右边, 下边)
	return e
}

// 元素_取内填充大小.
//
// pPadding: 大小.
func (e *X结构_基础元素) X取内填充大小(大小 *xc.X结构_矩形) *X结构_基础元素 {
	xc.X元素_取内填充大小(e.X句柄, 大小)
	return e
}

// 元素_取内填充大小ex.
func (e *X结构_基础元素) X取内填充大小EX() xc.X结构_矩形 {
	rc := xc.X结构_矩形{}
	xc.X元素_取内填充大小(e.X句柄, &rc)
	return rc
}

// 元素_置拖动边框.
//
// nFlags: 边框位置组合, xcc.Element_Position_.
func (e *X结构_基础元素) X设置拖动边框(边框位置组合 xcc.X元素位置) *X结构_基础元素 {
	xc.X元素_设置拖动边框(e.X句柄, 边框位置组合)
	return e
}

// 元素_置拖动边框绑定元素, 设置拖动边框绑定元素, 当拖动边框时, 自动调整绑定元素的大小.
//
// nFlags: 边框位置标识, xcc.Element_Position_.
//
// hBindEle: 绑定元素.
//
// nSpace: 元素间隔大小.
func (e *X结构_基础元素) X设置拖动边框绑定元素(边框位置标识 xcc.X元素位置, 绑定元素 int, 元素间隔大小 int32) *X结构_基础元素 {
	xc.X元素_设置拖动边框绑定元素(e.X句柄, 边框位置标识, 绑定元素, 元素间隔大小)
	return e
}

// 元素_置最小大小.
//
// nWidth: 最小宽度.
//
// nHeight: 最小高度.
func (e *X结构_基础元素) X设置最小大小(最小宽度, 最小高度 int32) *X结构_基础元素 {
	xc.X元素_设置最小大小(e.X句柄, 最小宽度, 最小高度)
	return e
}

// 元素_置最大大小.
//
// nWidth: 最大宽度.
//
// nHeight: 最大高度.
func (e *X结构_基础元素) X设置最大大小(最大宽度, 最大高度 int32) *X结构_基础元素 {
	xc.X元素_设置最大大小(e.X句柄, 最大宽度, 最大高度)
	return e
}

// 元素_置锁定滚动, 设置锁定元素在滚动视图中跟随滚动, 如果设置TRUE将不跟随滚动.
//
// bHorizon: 是否锁定水平滚动.
//
// bVertical: 是否锁定垂直滚动.
func (e *X结构_基础元素) X设置锁定滚动(是否锁定水平 bool, 是否锁定垂直 bool) *X结构_基础元素 {
	xc.X元素_设置锁定滚动(e.X句柄, 是否锁定水平, 是否锁定垂直)
	return e
}

// 元素_置文本颜色.
//
// color: xc.RGBA 颜色值.
func (e *X结构_基础元素) X设置文本颜色(ABGR颜色值 int) *X结构_基础元素 {
	xc.X元素_设置文本颜色(e.X句柄, ABGR颜色值)
	return e
}

// 元素_取文本颜色.
func (e *X结构_基础元素) X取文本颜色() int {
	return xc.X元素_取文本颜色(e.X句柄)
}

// 元素_取文本颜色扩展, 获取文本颜色, 优先从资源中获取.
func (e *X结构_基础元素) X取文本颜色EX() int {
	return xc.X元素_取文本颜色EX(e.X句柄)
}

// 元素_置焦点边框颜色.
//
// color: xc.RGBA 颜色值.
func (e *X结构_基础元素) X设置焦点边框颜色(ABGR颜色值 int) *X结构_基础元素 {
	xc.X元素_设置焦点边框颜色(e.X句柄, ABGR颜色值)
	return e
}

// 元素_取焦点边框颜色.
func (e *X结构_基础元素) X取焦点边框颜色() int {
	return xc.X元素_取焦点边框颜色(e.X句柄)
}

// 元素_置字体.
//
// hFontx: 炫彩字体.
func (e *X结构_基础元素) X设置字体(炫彩字体 int) *X结构_基础元素 {
	xc.X元素_设置字体(e.X句柄, 炫彩字体)
	return e
}

// 元素_取字体.
func (e *X结构_基础元素) X取字体() int {
	return xc.X元素_取字体(e.X句柄)
}

// 元素_取字体扩展, 获取元素字体, 优先从资源中获取.
func (e *X结构_基础元素) X取字体EX() int {
	return xc.X元素_取字体EX(e.X句柄)
}

// 元素_置透明度.
func (e *X结构_基础元素) X设置透明度(透明度 byte) *X结构_基础元素 {
	xc.X元素_设置透明度(e.X句柄, 透明度)
	return e
}

// 元素_销毁.
func (e *X结构_基础元素) X销毁() *X结构_基础元素 {
	xc.X元素_销毁(e.X句柄)
	return e
}

// 元素_添加背景边框, 添加背景内容边框.
//
// nState: 组合状态.
//
// color: xc.RGBA 颜色.
//
// width: 线宽.
func (e *X结构_基础元素) X添加背景边框(组合状态 xcc.X组合状态, 颜色 int, 线宽 int32) *X结构_基础元素 {
	xc.X元素_添加背景边框(e.X句柄, 组合状态, 颜色, 线宽)
	return e
}

// 元素_添加背景填充, 添加背景内容填充.
//
// nState: 组合状态.
//
// color: xc.RGBA 颜色.
func (e *X结构_基础元素) X添加背景填充(组合状态 xcc.X组合状态, 颜色 int) *X结构_基础元素 {
	xc.X元素_添加背景填充(e.X句柄, 组合状态, 颜色)
	return e
}

// 元素_添加背景图片, 添加背景内容图片.
//
// nState: 组合状态.
//
// hImage: 图片句柄.
func (e *X结构_基础元素) X添加背景图片(组合状态 xcc.X组合状态, 图片句柄 int) *X结构_基础元素 {
	xc.X元素_添加背景图片(e.X句柄, 组合状态, 图片句柄)
	return e
}

// 元素_取背景对象数量, 获取背景内容数量.
func (e *X结构_基础元素) X取背景对象数量() int32 {
	return xc.X元素_取背景对象数量(e.X句柄)
}

// 元素_清空背景对象, 清空背景内容; 如果背景没有内容, 将使用系统默认内容, 以便保证背景正确.
func (e *X结构_基础元素) X清空背景对象() *X结构_基础元素 {
	xc.X元素_清空背景对象(e.X句柄)
	return e
}

// 元素_取背景管理器, 获取元素背景管理器.
func (e *X结构_基础元素) X取背景管理器() int {
	return xc.X元素_取背景管理器(e.X句柄)
}

// 元素_取背景管理器扩展, 获取元素背景管理器, 优先从资源中获取.
func (e *X结构_基础元素) X取背景管理器EX() int {
	return xc.X元素_取背景管理器EX(e.X句柄)
}

// 元素_置背景管理器.
//
// hBkInfoM: 背景管理器.
func (e *X结构_基础元素) X设置背景管理器(背景管理器 int) *X结构_基础元素 {
	xc.X元素_设置背景管理器(e.X句柄, 背景管理器)
	return e
}

// 元素_取状态, 获取组合状态.
func (e *X结构_基础元素) X取状态() xcc.X组合状态 {
	return xc.X元素_取状态(e.X句柄)
}

// 元素_绘制焦点, 绘制元素焦点.
//
// hDraw: 图形绘制句柄.
//
// pRect: 区域坐标.
func (e *X结构_基础元素) X绘制焦点(图形绘制句柄 int, 矩形区域 *xc.X结构_矩形) bool {
	return xc.X元素_绘制焦点(e.X句柄, 图形绘制句柄, 矩形区域)
}

// 元素_绘制, 在自绘事件函数中, 用户手动调用绘制元素, 以便控制绘制顺序.
//
// hDraw: 图形绘制句柄.
func (e *X结构_基础元素) X绘制(图形绘制句柄 int) *X结构_基础元素 {
	xc.X元素_绘制(e.X句柄, 图形绘制句柄)
	return e
}

// 元素_置用户数据.
//
// nData: 用户数据.
func (e *X结构_基础元素) X设置用户数据(用户数据 int) *X结构_基础元素 {
	xc.X元素_设置用户数据(e.X句柄, 用户数据)
	return e
}

// 元素_取用户数据.
func (e *X结构_基础元素) X取用户数据() int {
	return xc.X元素_取用户数据(e.X句柄)
}

// 元素_取内容大小.
//
// bHorizon: 水平或垂直, 布局属性交换依赖.
//
// cx: 宽度.
//
// cy: 高度.
//
// pSize: 返回大小.
func (e *X结构_基础元素) X取内容大小(水平或垂直 bool, 宽度, 高度 int32, 返回大小 *xc.X结构_大小) *X结构_基础元素 {
	xc.X元素_取内容大小(e.X句柄, 水平或垂直, 宽度, 高度, 返回大小)
	return e
}

// 元素_置鼠标捕获.
//
// b: TRUE设置.
func (e *X结构_基础元素) X设置鼠标捕获(开启 bool) *X结构_基础元素 {
	xc.X元素_设置鼠标捕获(e.X句柄, 开启)
	return e
}

// 元素_启用透明通道, 启用或关闭元素透明通道, 如果启用, 将强制设置元素背景不透明, 默认为启用, 此功能是为了兼容GDI不支持透明通道问题.
//
// bEnable: 启用或关闭.
func (e *X结构_基础元素) X启用透明通道(启用或关闭 bool) *X结构_基础元素 {
	xc.X元素_启用透明通道(e.X句柄, 启用或关闭)
	return e
}

// 元素_置炫彩定时器, 设置元素定时器.
//
// nIDEvent: 事件ID.
//
// uElapse: 延时毫秒.
func (e *X结构_基础元素) X设置炫彩定时器(事件ID, 延时毫秒 uint32) bool {
	return xc.X元素_设置炫彩定时器(e.X句柄, 事件ID, 延时毫秒)
}

// 元素_关闭炫彩定时器, 关闭元素定时器.
//
// nIDEvent: 事件ID.
func (e *X结构_基础元素) X关闭炫彩定时器(事件ID uint32) bool {
	return xc.X元素_关闭炫彩定时器(e.X句柄, 事件ID)
}

// 元素_置工具提示, 设置工具提示内容.
//
// pText: 工具提示内容.
func (e *X结构_基础元素) X设置工具提示(内容 string) *X结构_基础元素 {
	xc.X元素_设置工具提示(e.X句柄, 内容)
	return e
}

// 元素_置工具提示扩展, 设置工具提示内容.
//
// pText: 工具提示内容.
//
// nTextAlign: 文本对齐方式, TextFormatFlag_, TextAlignFlag_, TextTrimming_.
func (e *X结构_基础元素) X设置工具提示EX(内容 string, 对齐方式 xcc.X文本对齐) *X结构_基础元素 {
	xc.X元素_设置工具提示EX(e.X句柄, 内容, 对齐方式)
	return e
}

// 元素_取工具提示, 获取工具提示内容.
func (e *X结构_基础元素) X取工具提示() string {
	return xc.X元素_取工具提示(e.X句柄)
}

// 元素_弹出工具提示, 弹出工具提示.
//
// x: X坐标.
//
// y: Y坐标.
func (e *X结构_基础元素) X弹出工具提示(坐标, Y坐标 int32) *X结构_基础元素 {
	xc.X元素_弹出工具提示(e.X句柄, 坐标, Y坐标)
	return e
}

// 元素_调整布局.
//
// nAdjustNo: 调整布局流水号, 可填0.
func (e *X结构_基础元素) X调整布局(流水号 uint32) *X结构_基础元素 {
	xc.X元素_调整布局(e.X句柄, 流水号)
	return e
}

// 元素_调整布局扩展.
//
// nFlags: 调整布局标识位: xcc.AdjustLayout_.
//
// nAdjustNo: 调整布局流水号, 可填0.
func (e *X结构_基础元素) X调整布局EX(标识 xcc.X调整布局标识位, 布局流水号 uint32) *X结构_基础元素 {
	xc.X元素_调整布局EX(e.X句柄, 标识, 布局流水号)
	return e
}

// 元素_取透明度, 返回透明度.
func (e *X结构_基础元素) X取透明度() byte {
	return xc.X元素_取透明度(e.X句柄)
}

// 元素_取位置.
//
// pOutX: 返回X坐标.
//
// pOutY: 返回Y坐标.
func (e *X结构_基础元素) X取位置(返回X坐标, 返回Y坐标 *int32) *X结构_基础元素 {
	xc.X元素_取位置(e.X句柄, 返回X坐标, 返回Y坐标)
	return e
}

// 元素_取位置ex.
func (e *X结构_基础元素) X取位置EX() xc.X结构_坐标 {
	var pOutX, pOutY int32
	xc.X元素_取位置(e.X句柄, &pOutX, &pOutY)
	return xc.X结构_坐标{X坐标: pOutX, Y坐标: pOutY}
}

// 元素_置大小.
//
// nWidth: 宽度.
//
// nHeight: 高度.
//
// bRedraw: 是否重绘.
//
// nFlags: 调整布局标识位: xcc.AdjustLayout_.
//
// nAdjustNo: 调整布局流水号, 可填0.
func (e *X结构_基础元素) X设置大小(宽度, 高度 int32, 是否重绘 bool, 标识 xcc.X调整布局标识位, 布局流水号 uint32) int32 {
	return xc.X元素_设置大小(e.X句柄, 宽度, 高度, 是否重绘, 标识, 布局流水号)
}

// 元素_取大小.
//
// pOutWidth: 返回宽度.
//
// pOutHeight: 返回高度.
func (e *X结构_基础元素) X取大小(返回宽度, 返回高度 *int32) *X结构_基础元素 {
	xc.X元素_取大小(e.X句柄, 返回宽度, 返回高度)
	return e
}

// 元素_取大小ex.
func (e *X结构_基础元素) X取大小EX() xc.X结构_坐标 {
	var pOutWidth, pOutHeight int32
	xc.X元素_取大小(e.X句柄, &pOutWidth, &pOutHeight)
	return xc.X结构_坐标{X坐标: pOutWidth, Y坐标: pOutHeight}
}

// 元素_置背景, 设置背景内容, 返回设置的背景对象数量.
//
// pText: 背景内容字符串.
func (e *X结构_基础元素) X设置背景(文本 string) int32 {
	return xc.X元素_设置背景(e.X句柄, 文本)
}

// 元素_取窗口客户区坐标DPI. 基于DPI缩放后的坐标.
//
// pRect: 接收返回坐标.
func (e *X结构_基础元素) X取窗口客户区坐标DPI(返回矩形 *xc.X结构_矩形) *X结构_基础元素 {
	xc.X元素_取窗口客户区坐标DPI(e.X句柄, 返回矩形)
	return e
}

// 元素_取窗口客户区坐标DPIex. 基于DPI缩放后的坐标.
func (e *X结构_基础元素) X取窗口客户区坐标DPIEX() xc.X结构_矩形 {
	rc := xc.X结构_矩形{}
	xc.X元素_取窗口客户区坐标DPI(e.X句柄, &rc)
	return rc
}

// 元素_取窗口客户区坐标DPI. 基于DPI缩放后的坐标.
//
// pPt: 接收返回坐标点.
func (e *X结构_基础元素) X取窗口客户区坐标点DPI(返回坐标 *xc.X结构_坐标) *X结构_基础元素 {
	xc.X元素_取窗口客户区坐标点DPI(e.X句柄, 返回坐标)
	return e
}

// 元素_取窗口客户区坐标DPIex. 基于DPI缩放后的坐标.
//
// pPt: 接收返回坐标点.
func (e *X结构_基础元素) X取窗口客户区坐标点DPIEX() xc.X结构_坐标 {
	pt := xc.X结构_坐标{}
	xc.X元素_取窗口客户区坐标点DPI(e.X句柄, &pt)
	return pt
}

// 元素_客户区坐标到窗口客户区DPI. 基于DPI缩放后的坐标.
//
// pRect: 接收返回坐标.
func (e *X结构_基础元素) X客户区坐标到窗口客户区DPI(返回矩形 *xc.X结构_矩形) *X结构_基础元素 {
	xc.X元素_客户区坐标到窗口客户区DPI(e.X句柄, 返回矩形)
	return e
}

// SetFocus 元素_置焦点.
func (e *X结构_基础元素) X设置焦点() bool {
	hParent := 0
	hEle := e.X句柄
	for {
		hParent = xc.X窗口组件_取父对象(hEle)
		if xc.X判断窗口(hParent) {
			break
		}

		if hParent == 0 {
			return false
		}

		hEle = hParent
	}

	xc.X窗口_设置焦点(hParent, e.X句柄)
	return true
}

// GetLeft 元素_取左边.
func (e *X结构_基础元素) X取左边() int32 {
	var rc xc.X结构_矩形
	xc.X元素_取坐标(e.X句柄, &rc)
	return rc.X左
}

// GetTop 元素_取顶边.
func (e *X结构_基础元素) X取顶边() int32 {
	var rc xc.X结构_矩形
	xc.X元素_取坐标(e.X句柄, &rc)
	return rc.X上
}

// GetRight 元素_取右边.
func (e *X结构_基础元素) X取右边() int32 {
	var rc xc.X结构_矩形
	xc.X元素_取坐标(e.X句柄, &rc)
	return rc.X右
}

// GetBottom 元素_取底边.
func (e *X结构_基础元素) X取底边() int32 {
	var rc xc.X结构_矩形
	xc.X元素_取坐标(e.X句柄, &rc)
	return rc.X下
}

// SetLeft 元素_置左边.
//
// x: 左边x坐标.
//
// bRedraw: 是否重绘.
func (e *X结构_基础元素) X设置左边(左边x坐标 int32, 是否重绘 bool) bool {
	return xc.X元素_移动(e.X句柄, 左边x坐标, e.X取顶边(), 是否重绘, xcc.X调整布局标识位_调整自身和子对象, 0) != 0
}

// SetLeft 元素_置顶边.
//
// y: 顶边y坐标.
//
// bRedraw: 是否重绘.
func (e *X结构_基础元素) X设置顶边(顶边y坐标 int32, 是否重绘 bool) bool {
	return xc.X元素_移动(e.X句柄, e.X取左边(), 顶边y坐标, 是否重绘, xcc.X调整布局标识位_调整自身和子对象, 0) != 0
}

// ------------------------- 事件 ------------------------- //

type X事件_处理过程 func(nEvent uint32, wParam, lParam uintptr, pbHandled *bool) int            // 元素处理过程事件.
type X事件_处理过程1 func(hEle int, nEvent uint32, wParam, lParam uintptr, pbHandled *bool) int // 元素处理过程事件.
type X事件_绘制事件 func(hDraw int, pbHandled *bool) int                                           // 元素绘制事件.
type X事件_绘制事件1 func(hEle int, hDraw int, pbHandled *bool) int                                // 元素绘制事件.
type X事件_绘制完成 func(hDraw int, pbHandled *bool) int                                       // 该元素及子元素绘制完成事件.启用该功能需要调用 xc.XEle_EnableEvent_XE_PAINT_END.
type X事件_绘制完成1 func(hEle int, hDraw int, pbHandled *bool) int                            // 该元素及子元素绘制完成事件.启用该功能需要调用 xc.XEle_EnableEvent_XE_PAINT_END.
type X事件_滚动视图 func(hDraw int, pbHandled *bool) int                                // 滚动视图绘制事件.
type X事件_滚动视图1 func(hEle int, hDraw int, pbHandled *bool) int                     // 滚动视图绘制事件.
type X事件_鼠标移动 func(nFlags int, pPt *xc.X结构_坐标, pbHandled *bool) int                       // 元素鼠标移动事件.
type X事件_鼠标移动1 func(hEle int, nFlags int, pPt *xc.X结构_坐标, pbHandled *bool) int            // 元素鼠标移动事件.
type X事件_鼠标进入 func(pbHandled *bool) int                                                  // 元素鼠标进入事件.
type X事件_鼠标进入1 func(hEle int, pbHandled *bool) int                                       // 元素鼠标进入事件.
type X事件_鼠标悬停 func(nFlags int, pPt *xc.X结构_坐标, pbHandled *bool) int                      // 元素鼠标悬停事件.
type X事件_鼠标悬停1 func(hEle int, nFlags int, pPt *xc.X结构_坐标, pbHandled *bool) int           // 元素鼠标悬停事件.
type X事件_鼠标离开 func(hEleStay int, pbHandled *bool) int                                   // 元素鼠标离开事件.
type X事件_鼠标离开1 func(hEle int, hEleStay int, pbHandled *bool) int                        // 元素鼠标离开事件.
type X事件_鼠标滚轮滚动 func(nFlags int, pPt *xc.X结构_坐标, pbHandled *bool) int                      // 元素鼠标滚轮滚动事件. 如果非滚动视图需要调用 xc.XEle_EnableEvent_XE_MOUSEWHEEL. flags: 见MSDN中 WM_MOUSEWHEEL 消息 wParam 参数说明.
type X事件_鼠标滚轮滚动1 func(hEle int, nFlags int, pPt *xc.X结构_坐标, pbHandled *bool) int           // 元素鼠标滚轮滚动事件. 如果非滚动视图需要调用 xc.XEle_EnableEvent_XE_MOUSEWHEEL. flags: 见MSDN中 WM_MOUSEWHEEL 消息 wParam 参数说明.
type X事件_左键按下 func(nFlags int, pPt *xc.X结构_坐标, pbHandled *bool) int                     // 鼠标左键按下事件.
type X事件_左键按下1 func(hEle int, nFlags int, pPt *xc.X结构_坐标, pbHandled *bool) int          // 鼠标左键按下事件.
type X事件_左键弹起 func(nFlags int, pPt *xc.X结构_坐标, pbHandled *bool) int                       // 鼠标左键弹起事件.
type X事件_左键弹起1 func(hEle int, nFlags int, pPt *xc.X结构_坐标, pbHandled *bool) int            // 鼠标左键弹起事件.
type X事件_右键按下 func(nFlags int, pPt *xc.X结构_坐标, pbHandled *bool) int                     // 鼠标右键按下事件.
type X事件_右键按下1 func(hEle int, nFlags int, pPt *xc.X结构_坐标, pbHandled *bool) int          // 鼠标右键按下事件.
type X事件_右键弹起 func(nFlags int, pPt *xc.X结构_坐标, pbHandled *bool) int                       // 鼠标右键弹起事件.
type X事件_右键弹起1 func(hEle int, nFlags int, pPt *xc.X结构_坐标, pbHandled *bool) int            // 鼠标右键弹起事件.
type X事件_左键双击 func(nFlags int, pPt *xc.X结构_坐标, pbHandled *bool) int                  // 鼠标左键双击事件.
type X事件_左键双击1 func(hEle int, nFlags int, pPt *xc.X结构_坐标, pbHandled *bool) int       // 鼠标左键双击事件.
type X事件_炫彩定时器 func(nTimerID int, pbHandled *bool) int                                     // 炫彩定时器,非系统定时器,定时器消息 XM_TIMER.
type X事件_炫彩定时器1 func(hEle int, nTimerID int, pbHandled *bool) int                          // 炫彩定时器,非系统定时器,定时器消息 XM_TIMER.
type X事件_调整布局 func(nFlags int32, nAdjustNo uint32, pbHandled *bool) int               // 调整布局事件. 暂停使用.
type X事件_调整布局1 func(hEle int, nFlags int32, nAdjustNo uint32, pbHandled *bool) int    // 调整布局事件. 暂停使用.
type X事件_工具提示弹出 func(hWindow int, pText uintptr, pbHandled *bool) int                  // 元素工具提示弹出事件.
type X事件_工具提示弹出1 func(hEle int, hWindow int, pText uintptr, pbHandled *bool) int       // 元素工具提示弹出事件1.

// 调整布局完成事件.
//
// nFlags: 调整布局标识位: xcc.AdjustLayout_.
//
// nAdjustNo: 调整布局流水号.
type X事件_调整布局完成 func(nFlags xcc.X调整布局标识位, nAdjustNo uint32, pbHandled *bool) int

// 调整布局完成事件.
//
// hEle: 元素句柄.
//
// nFlags: 调整布局标识位: xcc.AdjustLayout_.
//
// nAdjustNo: 调整布局流水号.
type X事件_调整布局完成1 func(hEle int, nFlags xcc.X调整布局标识位, nAdjustNo uint32, pbHandled *bool) int

type X事件_获得焦点 func(pbHandled *bool) int               // 元素获得焦点事件.
type X事件_获得焦点1 func(hEle int, pbHandled *bool) int    // 元素获得焦点事件.
type X事件_失去焦点 func(pbHandled *bool) int              // 元素失去焦点事件.
type X事件_失去焦点1 func(hEle int, pbHandled *bool) int   // 元素失去焦点事件.
type X事件_即将销毁 func(pbHandled *bool) int                // 元素即将销毁事件. 在销毁子对象之前触发.
type X事件_即将销毁1 func(hEle int, pbHandled *bool) int     // 元素即将销毁事件. 在销毁子对象之前触发.
type X事件_销毁完成 func(pbHandled *bool) int            // 元素销毁完成事件. 在销毁子对象之后触发.
type X事件_销毁完成1 func(hEle int, pbHandled *bool) int // 元素销毁完成事件. 在销毁子对象之后触发.

// 元素大小改变事件.
//
// nFlags: 调整布局标识位: xcc.AdjustLayout_.
//
// nAdjustNo: 调整布局流水号.
type X事件_大小改变事件 func(nFlags xcc.X调整布局标识位, nAdjustNo uint32, pbHandled *bool) int

// 元素大小改变事件1.
//
// hEle: 元素句柄.
//
// nFlags: 调整布局标识位: xcc.AdjustLayout_.
//
// nAdjustNo: 调整布局流水号.
type X事件_大小改变事件1 func(hEle int, nFlags xcc.X调整布局标识位, nAdjustNo uint32, pbHandled *bool) int

type X事件_显示隐藏事件 func(bShow bool, pbHandled *bool) int                              // 元素显示隐藏事件.
type X事件_显示隐藏事件1 func(hEle int, bShow bool, pbHandled *bool) int                   // 元素显示隐藏事件.
type X事件_设置字体 func(pbHandled *bool) int                                       // 元素设置字体事件.
type X事件_设置字体1 func(hEle int, pbHandled *bool) int                            // 元素设置字体事件.
type X事件_按键按下 func(wParam, lParam uintptr, pbHandled *bool) int               // 元素按键按下事件.
type X事件_按键按下1 func(hEle int, wParam, lParam uintptr, pbHandled *bool) int    // 元素按键按下事件.
type X事件_按键弹起 func(wParam, lParam uintptr, pbHandled *bool) int                 // 元素按键弹起事件.
type X事件_按键弹起1 func(hEle int, wParam, lParam uintptr, pbHandled *bool) int      // 元素按键弹起事件.
type XE_SYSKEYDOWN1 func(hEle int, wParam, lParam uintptr, pbHandled *bool) int // 元素系统按键按下事件.
type XE_SYSKEYUP1 func(hEle int, wParam, lParam uintptr, pbHandled *bool) int   // 元素系统按键弹起事件

type X事件_CHAR func(wParam, lParam uintptr, pbHandled *bool) int                 // 通过TranslateMessage函数翻译的字符事件.
type X事件_CHAR1 func(hEle int, wParam, lParam uintptr, pbHandled *bool) int      // 通过TranslateMessage函数翻译的字符事件.
type X事件_设置鼠标捕获 func(pbHandled *bool) int                                   // 元素设置鼠标捕获.
type X事件_设置鼠标捕获1 func(hEle int, pbHandled *bool) int                        // 元素设置鼠标捕获.
type X事件_失去鼠标捕获 func(pbHandled *bool) int                                  // 元素失去鼠标捕获.
type X事件_失去鼠标捕获1 func(hEle int, pbHandled *bool) int                       // 元素失去鼠标捕获.
type X事件_设置鼠标光标 func(wParam, lParam uintptr, pbHandled *bool) int            // 设置鼠标光标.
type X事件_设置鼠标光标1 func(hEle int, wParam, lParam uintptr, pbHandled *bool) int // 设置鼠标光标.
type X事件_文件拖放 func(hDropInfo uintptr, pbHandled *bool) int                 // 文件拖放事件, 需先启用: xc.XWnd_EnableDragFiles.
type X事件_文件拖放1 func(hEle int, hDropInfo uintptr, pbHandled *bool) int      // 文件拖放事件, 需先启用: xc.XWnd_EnableDragFiles.

// 元素处理过程事件.
func (e *X结构_基础元素) X事件_处理过程(回调函数 X事件_处理过程) bool {
	return xc.X元素_注册事件C(e.X句柄, xcc.X元素事件_处理过程, 回调函数)
}

// 元素处理过程事件.
func (e *X结构_基础元素) X事件_处理过程1(回调函数 X事件_处理过程1) bool {
	return xc.X元素_注册事件C1(e.X句柄, xcc.X元素事件_处理过程, 回调函数)
}

// 元素绘制事件.
func (e *X结构_基础元素) X事件_绘制事件(回调函数 X事件_绘制事件) bool {
	return xc.X元素_注册事件C(e.X句柄, xcc.X元素事件_绘制, 回调函数)
}

// 元素绘制事件.
func (e *X结构_基础元素) X事件_绘制事件1(回调函数 X事件_绘制事件1) bool {
	return xc.X元素_注册事件C1(e.X句柄, xcc.X元素事件_绘制, 回调函数)
}

// 该元素及子元素绘制完成事件.启用该功能需要调用 xc.XEle_EnableEvent_XE_PAINT_END.
func (e *X结构_基础元素) X事件_绘制完成(回调函数 X事件_绘制完成) bool {
	return xc.X元素_注册事件C(e.X句柄, xcc.X元素事件_绘制完成, 回调函数)
}

// 该元素及子元素绘制完成事件.启用该功能需要调用 xc.XEle_EnableEvent_XE_PAINT_END.
func (e *X结构_基础元素) X事件_绘制完成1(回调函数 X事件_绘制完成1) bool {
	return xc.X元素_注册事件C1(e.X句柄, xcc.X元素事件_绘制完成, 回调函数)
}

// 滚动视图绘制事件.
func (e *X结构_基础元素) X事件_滚动视图(回调函数 X事件_滚动视图) bool {
	return xc.X元素_注册事件C(e.X句柄, xcc.X元素事件_滚动视图_绘制, 回调函数)
}

// 滚动视图绘制事件.
func (e *X结构_基础元素) X事件_滚动视图1(回调函数 X事件_滚动视图1) bool {
	return xc.X元素_注册事件C1(e.X句柄, xcc.X元素事件_滚动视图_绘制, 回调函数)
}

// 元素鼠标移动事件.
func (e *X结构_基础元素) X事件_鼠标移动(回调函数 X事件_鼠标移动) bool {
	return xc.X元素_注册事件C(e.X句柄, xcc.X元素事件_鼠标_移动, 回调函数)
}

// 元素鼠标移动事件.
func (e *X结构_基础元素) X事件_鼠标移动1(回调函数 X事件_鼠标移动1) bool {
	return xc.X元素_注册事件C1(e.X句柄, xcc.X元素事件_鼠标_移动, 回调函数)
}

// 元素鼠标进入事件.
func (e *X结构_基础元素) X事件_鼠标进入(回调函数 X事件_鼠标进入) bool {
	return xc.X元素_注册事件C(e.X句柄, xcc.X元素事件_鼠标_进入, 回调函数)
}

// 元素鼠标进入事件.
func (e *X结构_基础元素) X事件_鼠标进入1(回调函数 X事件_鼠标进入1) bool {
	return xc.X元素_注册事件C1(e.X句柄, xcc.X元素事件_鼠标_进入, 回调函数)
}

// 元素鼠标悬停事件.
func (e *X结构_基础元素) X事件_鼠标悬停(回调函数 X事件_鼠标悬停) bool {
	return xc.X元素_注册事件C(e.X句柄, xcc.X元素事件_鼠标_悬停, 回调函数)
}

// 元素鼠标悬停事件.
func (e *X结构_基础元素) X事件_鼠标悬停1(回调函数 X事件_鼠标悬停1) bool {
	return xc.X元素_注册事件C1(e.X句柄, xcc.X元素事件_鼠标_悬停, 回调函数)
}

// 元素鼠标离开事件.
func (e *X结构_基础元素) X事件_鼠标离开(回调函数 X事件_鼠标离开) bool {
	return xc.X元素_注册事件C(e.X句柄, xcc.X元素事件_鼠标_离开, 回调函数)
}

// 元素鼠标离开事件.
func (e *X结构_基础元素) X事件_鼠标离开1(回调函数 X事件_鼠标离开1) bool {
	return xc.X元素_注册事件C1(e.X句柄, xcc.X元素事件_鼠标_离开, 回调函数)
}

// 元素鼠标滚轮滚动事件. 如果非滚动视图需要调用 xc.XEle_EnableEvent_XE_MOUSEWHEEL.
func (e *X结构_基础元素) X事件_鼠标滚轮滚动(回调函数 X事件_鼠标滚轮滚动) bool {
	return xc.X元素_注册事件C(e.X句柄, xcc.X元素事件_鼠标_滚轮滚动, 回调函数)
}

// 元素鼠标滚轮滚动事件. 如果非滚动视图需要调用 xc.XEle_EnableEvent_XE_MOUSEWHEEL.
func (e *X结构_基础元素) X事件_鼠标滚轮滚动1(回调函数 X事件_鼠标滚轮滚动1) bool {
	return xc.X元素_注册事件C1(e.X句柄, xcc.X元素事件_鼠标_滚轮滚动, 回调函数)
}

// 鼠标左键按下事件.
func (e *X结构_基础元素) X事件_左键按下(回调函数 X事件_左键按下) bool {
	return xc.X元素_注册事件C(e.X句柄, xcc.X元素事件_鼠标_左键按下, 回调函数)
}

// 鼠标左键按下事件.
func (e *X结构_基础元素) X事件_左键按下1(回调函数 X事件_左键按下1) bool {
	return xc.X元素_注册事件C1(e.X句柄, xcc.X元素事件_鼠标_左键按下, 回调函数)
}

// 鼠标左键弹起事件.
func (e *X结构_基础元素) X事件_左键弹起(回调函数 X事件_左键弹起) bool {
	return xc.X元素_注册事件C(e.X句柄, xcc.X元素事件_鼠标_左键弹起, 回调函数)
}

// 鼠标左键弹起事件.
func (e *X结构_基础元素) X事件_左键弹起1(回调函数 X事件_左键弹起1) bool {
	return xc.X元素_注册事件C1(e.X句柄, xcc.X元素事件_鼠标_左键弹起, 回调函数)
}

// 鼠标右键按下事件.
func (e *X结构_基础元素) X事件_右键按下(回调函数 X事件_右键按下) bool {
	return xc.X元素_注册事件C(e.X句柄, xcc.X元素事件_鼠标_右键按下, 回调函数)
}

// 鼠标右键按下事件.
func (e *X结构_基础元素) X事件_右键按下1(回调函数 X事件_右键按下1) bool {
	return xc.X元素_注册事件C1(e.X句柄, xcc.X元素事件_鼠标_右键按下, 回调函数)
}

// 鼠标右键弹起事件.
func (e *X结构_基础元素) X事件_右键弹起(回调函数 X事件_右键弹起) bool {
	return xc.X元素_注册事件C(e.X句柄, xcc.X元素事件_鼠标_右键弹起, 回调函数)
}

// 鼠标右键弹起事件.
func (e *X结构_基础元素) X事件_右键弹起1(回调函数 X事件_右键弹起1) bool {
	return xc.X元素_注册事件C1(e.X句柄, xcc.X元素事件_鼠标_右键弹起, 回调函数)
}

// 鼠标左键双击事件.
func (e *X结构_基础元素) X事件_左键双击(回调函数 X事件_左键双击) bool {
	return xc.X元素_注册事件C(e.X句柄, xcc.X元素事件_鼠标_左键双击, 回调函数)
}

// 鼠标左键双击事件.
func (e *X结构_基础元素) X事件_左键双击1(回调函数 X事件_左键双击1) bool {
	return xc.X元素_注册事件C1(e.X句柄, xcc.X元素事件_鼠标_左键双击, 回调函数)
}

// 炫彩定时器,非系统定时器,定时器消息 XM_TIMER.
func (e *X结构_基础元素) X事件_炫彩定时器(回调函数 X事件_炫彩定时器) bool {
	return xc.X元素_注册事件C(e.X句柄, xcc.X元素事件_炫彩定时器, 回调函数)
}

// 炫彩定时器,非系统定时器,定时器消息 XM_TIMER.
func (e *X结构_基础元素) X事件_炫彩定时器1(回调函数 X事件_炫彩定时器1) bool {
	return xc.X元素_注册事件C1(e.X句柄, xcc.X元素事件_炫彩定时器, 回调函数)
}

// 调整布局事件. 暂停使用.
func (e *X结构_基础元素) X事件_调整布局(回调函数 X事件_调整布局) bool {
	return xc.X元素_注册事件C(e.X句柄, xcc.X元素事件_布局_调整_暂停使用, 回调函数)
}

// 调整布局事件. 暂停使用.
func (e *X结构_基础元素) X事件_调整布局1(回调函数 X事件_调整布局1) bool {
	return xc.X元素_注册事件C1(e.X句柄, xcc.X元素事件_布局_调整_暂停使用, 回调函数)
}

// 调整布局完成事件.
func (e *X结构_基础元素) X事件_调整布局完成(回调函数 X事件_调整布局完成) bool {
	return xc.X元素_注册事件C(e.X句柄, xcc.X元素事件_布局_调整完成, 回调函数)
}

// 调整布局完成事件.
func (e *X结构_基础元素) X事件_调整布局完成1(回调函数 X事件_调整布局完成1) bool {
	return xc.X元素_注册事件C1(e.X句柄, xcc.X元素事件_布局_调整完成, 回调函数)
}

// 元素获得焦点事件.
func (e *X结构_基础元素) X事件_获得焦点(回调函数 X事件_获得焦点) bool {
	return xc.X元素_注册事件C(e.X句柄, xcc.X元素事件_获得焦点, 回调函数)
}

// 元素获得焦点事件.
func (e *X结构_基础元素) X事件_获得焦点1(回调函数 X事件_获得焦点1) bool {
	return xc.X元素_注册事件C1(e.X句柄, xcc.X元素事件_获得焦点, 回调函数)
}

// 元素失去焦点事件.
func (e *X结构_基础元素) X事件_失去焦点(回调函数 X事件_失去焦点) bool {
	return xc.X元素_注册事件C(e.X句柄, xcc.X元素事件_失去焦点, 回调函数)
}

// 元素失去焦点事件.
func (e *X结构_基础元素) X事件_失去焦点1(回调函数 X事件_失去焦点1) bool {
	return xc.X元素_注册事件C1(e.X句柄, xcc.X元素事件_失去焦点, 回调函数)
}

// 元素即将销毁事件. 在销毁子对象之前触发.
func (e *X结构_基础元素) X事件_即将销毁(回调函数 X事件_即将销毁) bool {
	return xc.X元素_注册事件C(e.X句柄, xcc.X元素事件_即将销毁, 回调函数)
}

// 元素即将销毁事件. 在销毁子对象之前触发.
func (e *X结构_基础元素) X事件_即将销毁1(回调函数 X事件_即将销毁1) bool {
	return xc.X元素_注册事件C1(e.X句柄, xcc.X元素事件_即将销毁, 回调函数)
}

// 元素销毁完成事件. 在销毁子对象之后触发.
func (e *X结构_基础元素) X事件_销毁完成(回调函数 X事件_销毁完成) bool {
	return xc.X元素_注册事件C(e.X句柄, xcc.X元素事件_销毁完成, 回调函数)
}

// 元素销毁完成事件. 在销毁子对象之后触发.
func (e *X结构_基础元素) X事件_销毁完成1(回调函数 X事件_销毁完成1) bool {
	return xc.X元素_注册事件C1(e.X句柄, xcc.X元素事件_销毁完成, 回调函数)
}

// 元素大小改变事件.
func (e *X结构_基础元素) X事件_大小改变事件(回调函数 X事件_大小改变事件) bool {
	return xc.X元素_注册事件C(e.X句柄, xcc.X元素事件_元素_大小改变, 回调函数)
}

// 元素大小改变事件.
func (e *X结构_基础元素) X事件_大小改变事件1(回调函数 X事件_大小改变事件1) bool {
	return xc.X元素_注册事件C1(e.X句柄, xcc.X元素事件_元素_大小改变, 回调函数)
}

// 元素显示隐藏事件.
func (e *X结构_基础元素) X事件_显示隐藏事件(回调函数 X事件_显示隐藏事件) bool {
	return xc.X元素_注册事件C(e.X句柄, xcc.X元素事件_元素_显示隐藏, 回调函数)
}

// 元素显示隐藏事件.
func (e *X结构_基础元素) X事件_显示隐藏事件1(回调函数 X事件_显示隐藏事件1) bool {
	return xc.X元素_注册事件C1(e.X句柄, xcc.X元素事件_元素_显示隐藏, 回调函数)
}

// 元素设置字体事件.
func (e *X结构_基础元素) X事件_设置字体(回调函数 X事件_设置字体) bool {
	return xc.X元素_注册事件C(e.X句柄, xcc.X元素事件_元素_设置字体, 回调函数)
}

// 元素设置字体事件.
func (e *X结构_基础元素) X事件_设置字体1(回调函数 X事件_设置字体1) bool {
	return xc.X元素_注册事件C1(e.X句柄, xcc.X元素事件_元素_设置字体, 回调函数)
}

// 元素按键按下事件.
func (e *X结构_基础元素) X事件_按键按下(回调函数 X事件_按键按下) bool {
	return xc.X元素_注册事件C(e.X句柄, xcc.X元素事件_键盘_按下, 回调函数)
}

// 元素按键按下事件.
func (e *X结构_基础元素) X事件_按键按下1(回调函数 X事件_按键按下1) bool {
	return xc.X元素_注册事件C1(e.X句柄, xcc.X元素事件_键盘_按下, 回调函数)
}

// 元素按键弹起事件.
func (e *X结构_基础元素) X事件_按键弹起(回调函数 X事件_按键弹起) bool {
	return xc.X元素_注册事件C(e.X句柄, xcc.X元素事件_键盘_弹起, 回调函数)
}

// 元素按键弹起事件.
func (e *X结构_基础元素) X事件_按键弹起1(回调函数 X事件_按键弹起1) bool {
	return xc.X元素_注册事件C1(e.X句柄, xcc.X元素事件_键盘_弹起, 回调函数)
}

// 元素系统按键按下事件.
func (e *X结构_基础元素) Event_SYSKEYDOWN1(pFun XE_SYSKEYDOWN1) bool {
	return xc.X元素_注册事件C1(e.X句柄, xcc.XE_SYSKEYDOWN, pFun)
}

// 元素系统按键弹起事件.
func (e *X结构_基础元素) Event_SYSKEYUP1(pFun XE_SYSKEYUP1) bool {
	return xc.X元素_注册事件C1(e.X句柄, xcc.XE_SYSKEYUP, pFun)
}

// 通过 TranslateMessage 函数翻译的字符事件.
func (e *X结构_基础元素) X事件_CHAR(回调函数 X事件_CHAR) bool {
	return xc.X元素_注册事件C(e.X句柄, xcc.X元素事件_字符, 回调函数)
}

// 通过TranslateMessage函数翻译的字符事件.
func (e *X结构_基础元素) X事件_CHAR1(回调函数 X事件_CHAR1) bool {
	return xc.X元素_注册事件C1(e.X句柄, xcc.X元素事件_字符, 回调函数)
}

// 元素设置鼠标捕获.
func (e *X结构_基础元素) X事件_设置鼠标捕获(回调函数 X事件_设置鼠标捕获) bool {
	return xc.X元素_注册事件C(e.X句柄, xcc.X元素事件_鼠标_设置捕获, 回调函数)
}

// 元素设置鼠标捕获.
func (e *X结构_基础元素) X事件_设置鼠标捕获1(回调函数 X事件_设置鼠标捕获1) bool {
	return xc.X元素_注册事件C1(e.X句柄, xcc.X元素事件_鼠标_设置捕获, 回调函数)
}

// 元素失去鼠标捕获.
func (e *X结构_基础元素) X事件_失去鼠标捕获(回调函数 X事件_失去鼠标捕获) bool {
	return xc.X元素_注册事件C(e.X句柄, xcc.X元素事件_鼠标_失去捕获, 回调函数)
}

// 元素失去鼠标捕获.
func (e *X结构_基础元素) X事件_失去鼠标捕获1(回调函数 X事件_失去鼠标捕获1) bool {
	return xc.X元素_注册事件C1(e.X句柄, xcc.X元素事件_鼠标_失去捕获, 回调函数)
}

// 设置鼠标光标.
func (e *X结构_基础元素) X事件_设置鼠标光标(回调函数 X事件_设置鼠标光标) bool {
	return xc.X元素_注册事件C(e.X句柄, xcc.X元素事件_鼠标_设置光标, 回调函数)
}

// 设置鼠标光标.
func (e *X结构_基础元素) X事件_设置鼠标光标1(回调函数 X事件_设置鼠标光标1) bool {
	return xc.X元素_注册事件C1(e.X句柄, xcc.X元素事件_鼠标_设置光标, 回调函数)
}

// 文件拖放事件, 需先启用: xc.XWnd_EnableDragFiles.
func (e *X结构_基础元素) X事件_文件拖放(回调函数 X事件_文件拖放) bool {
	return xc.X元素_注册事件C(e.X句柄, xcc.X元素事件_文件拖放, 回调函数)
}

// 文件拖放事件, 需先启用: xc.XWnd_EnableDragFiles.
func (e *X结构_基础元素) X事件_文件拖放事件1(回调函数 X事件_文件拖放1) bool {
	return xc.X元素_注册事件C1(e.X句柄, xcc.X元素事件_文件拖放, 回调函数)
}

// 事件_元素工具提示弹出, 可使用 common.UintPtrToString 把uintptr转换到文本.
func (e *X结构_基础元素) X事件_工具提示弹出(回调函数 X事件_工具提示弹出) bool {
	return xc.X元素_注册事件C(e.X句柄, xcc.X元素事件_元素工具提示弹出, 回调函数)
}

// 事件_元素工具提示弹出1, 可使用 common.UintPtrToString 把uintptr转换到文本.
func (e *X结构_基础元素) X事件_工具提示弹出1(回调函数 X事件_工具提示弹出1) bool {
	return xc.X元素_注册事件C1(e.X句柄, xcc.X元素事件_元素工具提示弹出, 回调函数)
}

type X事件_菜单_弹出项被选择 func(nID int32, pbHandled *bool) int                                          // 弹出菜单项选择事件.
type X事件_菜单_弹出 func(HMENUX int, pbHandled *bool) int                                          // 菜单弹出.
type X事件_菜单_退出 func(pbHandled *bool) int                                                       // 弹出菜单退出事件.
type X事件_菜单_弹出窗口 func(hMenu int, pInfo *xc.X结构_菜单弹出窗口, pbHandled *bool) int             // 菜单弹出窗口.
type X事件_菜单_绘制背景 func(hDraw int, pInfo *xc.X结构_菜单背景自绘, pbHandled *bool) int // 绘制菜单背景, 启用该功能需要调用 xc.XMenu_EnableDrawBackground.
type X事件_菜单_绘制项事件 func(hDraw int, pInfo *xc.X结构_菜单项自绘, pbHandled *bool) int              // 绘制菜单项事件, 启用该功能需要调用 xc.XMenu_EnableDrawItem.

// 事件_弹出菜单项被选择.
func (e *X结构_基础元素) X事件_弹出菜单项被选择(回调函数 X事件_菜单_弹出项被选择) bool {
	return xc.X元素_注册事件C(e.X句柄, xcc.X元素事件_菜单_项选择, 回调函数)
}

// 事件_菜单弹出.
func (e *X结构_基础元素) X事件_菜单弹出(回调函数 X事件_菜单_弹出) bool {
	return xc.X元素_注册事件C(e.X句柄, xcc.X元素事件_菜单_弹出, 回调函数)
}

// 事件_菜单退出.
func (e *X结构_基础元素) X事件_菜单退出(回调函数 X事件_菜单_退出) bool {
	return xc.X元素_注册事件C(e.X句柄, xcc.X元素事件_菜单_退出, 回调函数)
}

// 菜单弹出窗口.
func (e *X结构_基础元素) X事件_菜单弹出窗口(回调函数 X事件_菜单_弹出窗口) bool {
	return xc.X元素_注册事件C(e.X句柄, xcc.X元素事件_菜单_弹出窗口, 回调函数)
}

// 绘制菜单背景, 启用该功能需要调用 xc.XMenu_EnableDrawBackground.
func (e *X结构_基础元素) X事件_绘制菜单背景(回调函数 X事件_菜单_绘制背景) bool {
	return xc.X元素_注册事件C(e.X句柄, xcc.X元素事件_菜单_绘制背景, 回调函数)
}

// 绘制菜单项事件, 启用该功能需要调用 xc.XMenu_EnableDrawItem.
func (e *X结构_基础元素) X事件_绘制菜单项事件(回调函数 X事件_菜单_绘制项事件) bool {
	return xc.X元素_注册事件C(e.X句柄, xcc.X元素事件_菜单_绘制项事件, 回调函数)
}

type X事件_菜单_弹出项被选择1 func(hEle int, nID int32, pbHandled *bool) int                                          // 弹出菜单项选择事件.
type X事件_菜单_弹出1 func(hEle int, HMENUX int, pbHandled *bool) int                                          // 菜单弹出.
type X事件_菜单_退出1 func(hEle int, pbHandled *bool) int                                                       // 弹出菜单退出事件.
type X事件_菜单_弹出窗口1 func(hEle int, hMenu int, pInfo *xc.X结构_菜单弹出窗口, pbHandled *bool) int             // 菜单弹出窗口.
type X事件_菜单_绘制背景1 func(hEle int, hDraw int, pInfo *xc.X结构_菜单背景自绘, pbHandled *bool) int // 绘制菜单背景, 启用该功能需要调用 xc.XMenu_EnableDrawBackground.
type X事件_菜单_绘制项1 func(hEle int, hDraw int, pInfo *xc.X结构_菜单项自绘, pbHandled *bool) int              // 绘制菜单项事件, 启用该功能需要调用 xc.XMenu_EnableDrawItem.

// 事件_弹出菜单项被选择.
func (e *X结构_基础元素) X事件_弹出菜单项被选择1(回调函数 X事件_菜单_弹出项被选择1) bool {
	return xc.X元素_注册事件C1(e.X句柄, xcc.X元素事件_菜单_项选择, 回调函数)
}

// 事件_菜单弹出.
func (e *X结构_基础元素) X事件_菜单弹出1(回调函数 X事件_菜单_弹出1) bool {
	return xc.X元素_注册事件C1(e.X句柄, xcc.X元素事件_菜单_弹出, 回调函数)
}

// 事件_菜单退出.
func (e *X结构_基础元素) X事件_菜单退出1(回调函数 X事件_菜单_退出1) bool {
	return xc.X元素_注册事件C1(e.X句柄, xcc.X元素事件_菜单_退出, 回调函数)
}

// 菜单弹出窗口.
func (e *X结构_基础元素) X事件_菜单弹出窗口1(回调函数 X事件_菜单_弹出窗口1) bool {
	return xc.X元素_注册事件C1(e.X句柄, xcc.X元素事件_菜单_弹出窗口, 回调函数)
}

// 绘制菜单背景, 启用该功能需要调用 xc.XMenu_EnableDrawBackground.
func (e *X结构_基础元素) X事件_绘制菜单背景1(回调函数 X事件_菜单_绘制背景1) bool {
	return xc.X元素_注册事件C1(e.X句柄, xcc.X元素事件_菜单_绘制背景, 回调函数)
}

// 绘制菜单项事件, 启用该功能需要调用 xc.XMenu_EnableDrawItem.
func (e *X结构_基础元素) X事件_绘制菜单项1(回调函数 X事件_菜单_绘制项1) bool {
	return xc.X元素_注册事件C1(e.X句柄, xcc.X元素事件_菜单_绘制项事件, 回调函数)
}

// ------------------------- AddEvent ------------------------- //

// AddEvent_Destroy_End 添加元素销毁完成事件. 在销毁子对象之后触发.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (e *X结构_基础元素) AddEvent_Destroy_End(pFun X事件_销毁完成1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(e.X句柄, xcc.X元素事件_销毁完成, onXE_DESTROY_END, pFun, allowAddingMultiple...)
}

// onXE_DESTROY_END 元素销毁完成事件. 在销毁子对象之后触发.
func onXE_DESTROY_END(hEle int, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_销毁完成)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_销毁完成1)(hEle, pbHandled)
			if *pbHandled {
				break
			}
		}
	}

	EventHandler.RemoveAllCallBack(hEle)
	return ret
}

// AddEvent_EleProce 添加元素处理过程事件.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (e *X结构_基础元素) AddEvent_EleProce(pFun X事件_处理过程1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(e.X句柄, xcc.X元素事件_处理过程, onXE_ELEPROCE, pFun, allowAddingMultiple...)
}

// onXE_ELEPROCE 元素处理过程事件.
func onXE_ELEPROCE(hEle int, nEvent uint32, wParam, lParam uintptr, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_处理过程)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_处理过程1)(hEle, nEvent, wParam, lParam, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_Paint 添加元素绘制事件.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (e *X结构_基础元素) AddEvent_Paint(pFun X事件_绘制事件1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(e.X句柄, xcc.X元素事件_绘制, onXE_PAINT, pFun, allowAddingMultiple...)
}

// onXE_PAINT 元素绘制事件.
func onXE_PAINT(hEle int, hDraw int, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_绘制)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_绘制事件1)(hEle, hDraw, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_Paint_End 添加该元素及子元素绘制完成事件.启用该功能需要调用 xc.XEle_EnableEvent_XE_PAINT_END.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (e *X结构_基础元素) AddEvent_Paint_End(pFun X事件_绘制完成1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(e.X句柄, xcc.X元素事件_绘制完成, onXE_PAINT_END, pFun, allowAddingMultiple...)
}

// onXE_PAINT_END 该元素及子元素绘制完成事件.
func onXE_PAINT_END(hEle int, hDraw int, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_绘制完成)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_绘制完成1)(hEle, hDraw, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_Paint_Scrollview 添加滚动视图绘制事件.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (e *X结构_基础元素) AddEvent_Paint_Scrollview(pFun X事件_滚动视图1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(e.X句柄, xcc.X元素事件_滚动视图_绘制, onXE_PAINT_SCROLLVIEW, pFun, allowAddingMultiple...)
}

// onXE_PAINT_SCROLLVIEW 滚动视图绘制事件.
func onXE_PAINT_SCROLLVIEW(hEle int, hDraw int, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_滚动视图_绘制)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_滚动视图1)(hEle, hDraw, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_MouseMove 添加元素鼠标移动事件.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (e *X结构_基础元素) AddEvent_MouseMove(pFun X事件_鼠标移动1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(e.X句柄, xcc.X元素事件_鼠标_移动, onXE_MOUSEMOVE, pFun, allowAddingMultiple...)
}

// onXE_MOUSEMOVE 元素鼠标移动事件.
func onXE_MOUSEMOVE(hEle int, nFlags int, pPt *xc.X结构_坐标, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_鼠标_移动)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_鼠标移动1)(hEle, nFlags, pPt, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_MouseStay 添加元素鼠标进入事件.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (e *X结构_基础元素) AddEvent_MouseStay(pFun X事件_鼠标进入1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(e.X句柄, xcc.X元素事件_鼠标_进入, onXE_MOUSESTAY, pFun, allowAddingMultiple...)
}

// onXE_MOUSESTAY 元素鼠标进入事件.
func onXE_MOUSESTAY(hEle int, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_鼠标_进入)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_鼠标进入1)(hEle, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_MouseHover 添加元素鼠标悬停事件.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (e *X结构_基础元素) AddEvent_MouseHover(pFun X事件_鼠标悬停1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(e.X句柄, xcc.X元素事件_鼠标_悬停, onXE_MOUSEHOVER, pFun, allowAddingMultiple...)
}

// onXE_MOUSEHOVER 元素鼠标悬停事件.
func onXE_MOUSEHOVER(hEle int, nFlags int, pPt *xc.X结构_坐标, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_鼠标_悬停)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_鼠标悬停1)(hEle, nFlags, pPt, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_MouseLeave 添加元素鼠标离开事件.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (e *X结构_基础元素) AddEvent_MouseLeave(pFun X事件_鼠标离开1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(e.X句柄, xcc.X元素事件_鼠标_离开, onXE_MOUSELEAVE, pFun, allowAddingMultiple...)
}

// onXE_MOUSELEAVE 元素鼠标离开事件.
func onXE_MOUSELEAVE(hEle int, hEleStay int, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_鼠标_离开)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_鼠标离开1)(hEle, hEleStay, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_MouseWheel 添加元素鼠标滚轮滚动事件. 如果非滚动视图需要调用 xc.XEle_EnableEvent_XE_MOUSEWHEEL. flags: 见MSDN中 WM_MOUSEWHEEL 消息 wParam 参数说明.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (e *X结构_基础元素) AddEvent_MouseWheel(pFun X事件_鼠标滚轮滚动1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(e.X句柄, xcc.X元素事件_鼠标_滚轮滚动, onXE_MOUSEWHEEL, pFun, allowAddingMultiple...)
}

// onXE_MOUSEWHEEL 元素鼠标滚轮滚动事件.
func onXE_MOUSEWHEEL(hEle int, nFlags int, pPt *xc.X结构_坐标, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_鼠标_滚轮滚动)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_鼠标滚轮滚动1)(hEle, nFlags, pPt, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_LButtonDown 添加鼠标左键按下事件.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (e *X结构_基础元素) AddEvent_LButtonDown(pFun X事件_左键按下1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(e.X句柄, xcc.X元素事件_鼠标_左键按下, onXE_LBUTTONDOWN, pFun, allowAddingMultiple...)
}

// onXE_LBUTTONDOWN 鼠标左键按下事件.
func onXE_LBUTTONDOWN(hEle int, nFlags int, pPt *xc.X结构_坐标, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_鼠标_左键按下)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_左键按下1)(hEle, nFlags, pPt, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_LButtonUp 添加鼠标左键弹起事件.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (e *X结构_基础元素) AddEvent_LButtonUp(pFun X事件_左键弹起1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(e.X句柄, xcc.X元素事件_鼠标_左键弹起, onXE_LBUTTONUP, pFun, allowAddingMultiple...)
}

// onXE_LBUTTONUP 鼠标左键弹起事件.
func onXE_LBUTTONUP(hEle int, nFlags int, pPt *xc.X结构_坐标, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_鼠标_左键弹起)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_左键弹起1)(hEle, nFlags, pPt, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_RButtonDown 添加鼠标右键按下事件.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (e *X结构_基础元素) AddEvent_RButtonDown(pFun X事件_右键按下1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(e.X句柄, xcc.X元素事件_鼠标_右键按下, onXE_RBUTTONDOWN, pFun, allowAddingMultiple...)
}

// onXE_RBUTTONDOWN 鼠标右键按下事件.
func onXE_RBUTTONDOWN(hEle int, nFlags int, pPt *xc.X结构_坐标, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_鼠标_右键按下)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_右键按下1)(hEle, nFlags, pPt, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_RButtonUp 添加鼠标右键弹起事件.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (e *X结构_基础元素) AddEvent_RButtonUp(pFun X事件_右键弹起1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(e.X句柄, xcc.X元素事件_鼠标_右键弹起, onXE_RBUTTONUP, pFun, allowAddingMultiple...)
}

// onXE_RBUTTONUP 鼠标右键弹起事件.
func onXE_RBUTTONUP(hEle int, nFlags int, pPt *xc.X结构_坐标, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_鼠标_右键弹起)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_右键弹起1)(hEle, nFlags, pPt, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_LButtonDBClick 添加鼠标左键双击事件.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (e *X结构_基础元素) AddEvent_LButtonDBClick(pFun X事件_左键双击1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(e.X句柄, xcc.X元素事件_鼠标_左键双击, onXE_LBUTTONDBCLICK, pFun, allowAddingMultiple...)
}

// onXE_LBUTTONDBCLICK 鼠标左键双击事件.
func onXE_LBUTTONDBCLICK(hEle int, nFlags int, pPt *xc.X结构_坐标, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_鼠标_左键双击)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_左键双击1)(hEle, nFlags, pPt, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_XC_Timer 添加炫彩定时器事件. 非系统定时器, 定时器消息 XM_TIMER.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (e *X结构_基础元素) AddEvent_XC_Timer(pFun X事件_炫彩定时器1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(e.X句柄, xcc.X元素事件_炫彩定时器, onXE_XC_TIMER, pFun, allowAddingMultiple...)
}

// onXE_XC_TIMER 炫彩定时器事件.
func onXE_XC_TIMER(hEle int, nTimerID int, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_炫彩定时器)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_炫彩定时器1)(hEle, nTimerID, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_AdjustLayout 添加调整布局事件. 暂停使用.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (e *X结构_基础元素) AddEvent_AdjustLayout(pFun X事件_调整布局1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(e.X句柄, xcc.X元素事件_布局_调整_暂停使用, onXE_ADJUSTLAYOUT, pFun, allowAddingMultiple...)
}

// onXE_ADJUSTLAYOUT 调整布局事件.
func onXE_ADJUSTLAYOUT(hEle int, nFlags int32, nAdjustNo uint32, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_布局_调整_暂停使用)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_调整布局1)(hEle, nFlags, nAdjustNo, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_ToolTip_Popup 添加工具提示弹出事件.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (e *X结构_基础元素) AddEvent_ToolTip_Popup(pFun X事件_工具提示弹出1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(e.X句柄, xcc.X元素事件_元素工具提示弹出, onXE_TOOLTIP_POPUP, pFun, allowAddingMultiple...)
}

// onXE_TOOLTIP_POPUP 工具提示弹出事件.
func onXE_TOOLTIP_POPUP(hEle int, hWindow int, pText uintptr, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_元素工具提示弹出)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_工具提示弹出1)(hEle, hWindow, pText, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_AdjustLayout_End 添加调整布局完成事件.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (e *X结构_基础元素) AddEvent_AdjustLayout_End(pFun X事件_调整布局完成1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(e.X句柄, xcc.X元素事件_布局_调整完成, onXE_ADJUSTLAYOUT_END, pFun, allowAddingMultiple...)
}

// onXE_ADJUSTLAYOUT_END 调整布局完成事件.
func onXE_ADJUSTLAYOUT_END(hEle int, nFlags xcc.X调整布局标识位, nAdjustNo uint32, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_布局_调整完成)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_调整布局完成1)(hEle, nFlags, nAdjustNo, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_SetFocus 添加元素获得焦点事件.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (e *X结构_基础元素) AddEvent_SetFocus(pFun X事件_获得焦点1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(e.X句柄, xcc.X元素事件_获得焦点, onXE_SETFOCUS, pFun, allowAddingMultiple...)
}

// onXE_SETFOCUS 元素获得焦点事件.
func onXE_SETFOCUS(hEle int, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_获得焦点)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_获得焦点1)(hEle, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_KillFocus 添加元素失去焦点事件.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (e *X结构_基础元素) AddEvent_KillFocus(pFun X事件_失去焦点1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(e.X句柄, xcc.X元素事件_失去焦点, onXE_KILLFOCUS, pFun, allowAddingMultiple...)
}

// onXE_KILLFOCUS 元素失去焦点事件.
func onXE_KILLFOCUS(hEle int, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_失去焦点)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_失去焦点1)(hEle, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_Destroy 添加元素即将销毁事件. 在销毁子对象之前触发.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (e *X结构_基础元素) AddEvent_Destroy(pFun X事件_即将销毁1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(e.X句柄, xcc.X元素事件_即将销毁, onXE_DESTROY, pFun, allowAddingMultiple...)
}

// onXE_DESTROY 元素即将销毁事件.
func onXE_DESTROY(hEle int, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_即将销毁)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_即将销毁1)(hEle, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_Size 添加元素大小改变事件.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (e *X结构_基础元素) AddEvent_Size(pFun X事件_大小改变事件1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(e.X句柄, xcc.X元素事件_元素_大小改变, onXE_SIZE, pFun, allowAddingMultiple...)
}

// onXE_SIZE 元素大小改变事件.
func onXE_SIZE(hEle int, nFlags xcc.X调整布局标识位, nAdjustNo uint32, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_元素_大小改变)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_大小改变事件1)(hEle, nFlags, nAdjustNo, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_Show 添加元素显示隐藏事件.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (e *X结构_基础元素) AddEvent_Show(pFun X事件_显示隐藏事件1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(e.X句柄, xcc.X元素事件_元素_显示隐藏, onXE_SHOW, pFun, allowAddingMultiple...)
}

// onXE_SHOW 元素显示隐藏事件.
func onXE_SHOW(hEle int, bShow bool, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_元素_显示隐藏)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_显示隐藏事件1)(hEle, bShow, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_SetFont 添加元素设置字体事件.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (e *X结构_基础元素) AddEvent_SetFont(pFun X事件_设置字体1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(e.X句柄, xcc.X元素事件_元素_设置字体, onXE_SETFONT, pFun, allowAddingMultiple...)
}

// onXE_SETFONT 元素设置字体事件.
func onXE_SETFONT(hEle int, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_元素_设置字体)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_设置字体1)(hEle, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_KeyDown 添加元素按键按下事件.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (e *X结构_基础元素) AddEvent_KeyDown(pFun X事件_按键按下1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(e.X句柄, xcc.X元素事件_键盘_按下, onXE_KEYDOWN, pFun, allowAddingMultiple...)
}

// onXE_KEYDOWN 元素按键按下事件.
func onXE_KEYDOWN(hEle int, wParam, lParam uintptr, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_键盘_按下)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_按键按下1)(hEle, wParam, lParam, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_KeyUp 添加元素按键弹起事件.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (e *X结构_基础元素) AddEvent_KeyUp(pFun X事件_按键弹起1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(e.X句柄, xcc.X元素事件_键盘_弹起, onXE_KEYUP, pFun, allowAddingMultiple...)
}

// onXE_KEYUP 元素按键弹起事件.
func onXE_KEYUP(hEle int, wParam, lParam uintptr, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_键盘_弹起)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_按键弹起1)(hEle, wParam, lParam, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_SysKeyDown 添加元素系统按键按下事件.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (e *X结构_基础元素) AddEvent_SysKeyDown(pFun XE_SYSKEYDOWN1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(e.X句柄, xcc.XE_SYSKEYDOWN, onXE_SYSKEYDOWN, pFun, allowAddingMultiple...)
}

// onXE_SYSKEYDOWN 元素系统按键按下事件.
func onXE_SYSKEYDOWN(hEle int, wParam, lParam uintptr, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.XE_SYSKEYDOWN)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(XE_SYSKEYDOWN1)(hEle, wParam, lParam, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_SysKeyUp 添加元素系统按键弹起事件.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (e *X结构_基础元素) AddEvent_SysKeyUp(pFun XE_SYSKEYUP1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(e.X句柄, xcc.XE_SYSKEYUP, onXE_SYSKEYUP, pFun, allowAddingMultiple...)
}

// onXE_SYSKEYUP 元素系统按键弹起事件.
func onXE_SYSKEYUP(hEle int, wParam, lParam uintptr, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.XE_SYSKEYUP)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(XE_SYSKEYUP1)(hEle, wParam, lParam, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_Char 添加字符输入事件.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (e *X结构_基础元素) AddEvent_Char(pFun X事件_CHAR1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(e.X句柄, xcc.X元素事件_字符, onXE_CHAR, pFun, allowAddingMultiple...)
}

// onXE_CHAR 字符输入事件.
func onXE_CHAR(hEle int, wParam, lParam uintptr, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_字符)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_CHAR1)(hEle, wParam, lParam, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_SetCapture 添加元素设置鼠标捕获事件.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (e *X结构_基础元素) AddEvent_SetCapture(pFun X事件_设置鼠标捕获1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(e.X句柄, xcc.X元素事件_鼠标_设置捕获, onXE_SETCAPTURE, pFun, allowAddingMultiple...)
}

// onXE_SETCAPTURE 元素设置鼠标捕获事件.
func onXE_SETCAPTURE(hEle int, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_鼠标_设置捕获)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_设置鼠标捕获1)(hEle, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_KillCapture 添加元素失去鼠标捕获事件.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (e *X结构_基础元素) AddEvent_KillCapture(pFun X事件_失去鼠标捕获1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(e.X句柄, xcc.X元素事件_鼠标_失去捕获, onXE_KILLCAPTURE, pFun, allowAddingMultiple...)
}

// onXE_KILLCAPTURE 元素失去鼠标捕获事件.
func onXE_KILLCAPTURE(hEle int, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_鼠标_失去捕获)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_失去鼠标捕获1)(hEle, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_SetCursor 添加元素设置鼠标光标事件.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (e *X结构_基础元素) AddEvent_SetCursor(pFun X事件_设置鼠标光标1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(e.X句柄, xcc.X元素事件_鼠标_设置光标, onXE_SETCURSOR, pFun, allowAddingMultiple...)
}

// onXE_SETCURSOR 元素设置鼠标光标事件.
func onXE_SETCURSOR(hEle int, wParam, lParam uintptr, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_鼠标_设置光标)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_设置鼠标光标1)(hEle, wParam, lParam, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_DropFiles 添加文件拖放事件. 需先启用: xc.XWnd_EnableDragFiles.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (e *X结构_基础元素) AddEvent_DropFiles(pFun X事件_文件拖放1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(e.X句柄, xcc.X元素事件_文件拖放, onXE_DROPFILES, pFun, allowAddingMultiple...)
}

// onXE_DROPFILES 文件拖放事件.
func onXE_DROPFILES(hEle int, hDropInfo uintptr, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_文件拖放)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_文件拖放1)(hEle, hDropInfo, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_Menu_Select 添加弹出菜单项选择事件.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (e *X结构_基础元素) AddEvent_Menu_Select(pFun X事件_菜单_弹出项被选择1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(e.X句柄, xcc.X元素事件_菜单_项选择, onXE_MENU_SELECT, pFun, allowAddingMultiple...)
}

// onXE_MENU_SELECT 弹出菜单项选择事件.
func onXE_MENU_SELECT(hEle int, nID int32, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_菜单_项选择)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_菜单_弹出项被选择1)(hEle, nID, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_Menu_Popup 添加菜单弹出事件.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (e *X结构_基础元素) AddEvent_Menu_Popup(pFun X事件_菜单_弹出1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(e.X句柄, xcc.X元素事件_菜单_弹出, onXE_MENU_POPUP, pFun, allowAddingMultiple...)
}

// onXE_MENU_POPUP 菜单弹出事件.
func onXE_MENU_POPUP(hEle int, HMENUX int, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_菜单_弹出)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_菜单_弹出1)(hEle, HMENUX, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_Menu_Exit 添加菜单退出事件.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (e *X结构_基础元素) AddEvent_Menu_Exit(pFun X事件_菜单_退出1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(e.X句柄, xcc.X元素事件_菜单_退出, onXE_MENU_EXIT, pFun, allowAddingMultiple...)
}

// onXE_MENU_EXIT 菜单退出事件.
func onXE_MENU_EXIT(hEle int, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_菜单_退出)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_菜单_退出1)(hEle, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_Menu_Popup_Wnd 添加菜单弹出窗口事件.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (e *X结构_基础元素) AddEvent_Menu_Popup_Wnd(pFun X事件_菜单_弹出窗口1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(e.X句柄, xcc.X元素事件_菜单_弹出窗口, onXE_MENU_POPUP_WND, pFun, allowAddingMultiple...)
}

// onXE_MENU_POPUP_WND 菜单弹出窗口事件.
func onXE_MENU_POPUP_WND(hEle int, hMenu int, pInfo *xc.X结构_菜单弹出窗口, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_菜单_弹出窗口)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_菜单_弹出窗口1)(hEle, hMenu, pInfo, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_Menu_Draw_Background 添加菜单绘制背景事件. 启用该功能需要调用 xc.XMenu_EnableDrawBackground.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (e *X结构_基础元素) AddEvent_Menu_Draw_Background(pFun X事件_菜单_绘制背景1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(e.X句柄, xcc.X元素事件_菜单_绘制背景, onXE_MENU_DRAW_BACKGROUND, pFun, allowAddingMultiple...)
}

// onXE_MENU_DRAW_BACKGROUND 菜单绘制背景事件.
func onXE_MENU_DRAW_BACKGROUND(hEle int, hDraw int, pInfo *xc.X结构_菜单背景自绘, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_菜单_绘制背景)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_菜单_绘制背景1)(hEle, hDraw, pInfo, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_Menu_DrawItem 添加菜单项绘制事件. 启用该功能需要调用 xc.XMenu_EnableDrawItem.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (e *X结构_基础元素) AddEvent_Menu_DrawItem(pFun X事件_菜单_绘制项1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(e.X句柄, xcc.X元素事件_菜单_绘制项事件, onXE_MENU_DRAWITEM, pFun, allowAddingMultiple...)
}

// onXE_MENU_DRAWITEM 菜单项绘制事件.
func onXE_MENU_DRAWITEM(hEle int, hDraw int, pInfo *xc.X结构_菜单项自绘, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_菜单_绘制项事件)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_菜单_绘制项1)(hEle, hDraw, pInfo, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}
